import java.util.*;

/*
高斯消元解线性方程组
输入一个包含 n 个方程 n 个未知数的线性方程组。
方程组中的系数为实数。
求解这个方程组。

输入格式
第一行包含整数 n。
接下来 n 行，每行包含 n+1 个实数，表示一个方程的 n 个系数以及等号右侧的常数。

输出格式
如果给定线性方程组存在唯一解，则输出共 n 行，其中第 i 行输出第 i 个未知数的解，结果保留两位小数。
如果给定线性方程组存在无数解，则输出 Infinite group solutions。
如果给定线性方程组无解，则输出 No solution。

数据范围
1≤n≤100,
所有输入系数以及常数均保留两位小数，绝对值均不超过 100。

输入样例：
3
1.00 2.00 -1.00 -6.00
2.00 1.00 -3.00 -9.00
-1.00 -1.00 2.00 7.00
输出样例：
1.00
-2.00
3.00
 */
public class Main {
    static double[][] a = new double[101][101];
    static int n;
    static double eps = 1e-6;

    static int gaussJordanElimination() {
        int row = 0, col = 0;
        for (; col < n; col++) {
            //找到绝对值最大的一行
            int maxAbsRow = row;
            for (int i = row; i < n; i++) {
                if (Math.abs(a[i][col]) > Math.abs(a[maxAbsRow][col])) {
                    maxAbsRow = i;
                }
            }
            //如果绝对值最大的一行对应的数为0,continue
            if (Math.abs(a[maxAbsRow][col]) < eps) continue;
            //把这一行换到未处理的最上面
            for (int i = 0; i <= n; i++) {
                double tmp = a[row][i];
                a[row][i] = a[maxAbsRow][i];
                a[maxAbsRow][i] = tmp;
            }
            //把这一行(第row行)的第col个数变成1(0-col个数都是0)
            for (int i = n; i >= col; i--) {
                a[row][i] /= a[row][col];
            }
            //把下面所有行的第col列消成0
            for (int i = row + 1; i < n; i++) {
                if (Math.abs(a[i][col]) > eps) {
                    for (int j = n; j >= col; j--) {
                        a[i][j] -= a[row][j] * a[i][col];
                    }
                }
            }
            //更新行
            ++row;
        }
        if (row < n) {
            for (int i = row; i < n; i++) {
                //如果第row+1~n行的最后一个数不为0，无解
                if (Math.abs(a[i][n]) > eps)
                    return 2;
            }
            //否则有无数多解
            return 1;
        }
        //处理解
        for (int i = n - 1; i >= 0; i--) {
            for (int j = i + 1; j < n; j++) {
                a[i][n] -= a[i][j] * a[j][n];
            }
        }
        return 0;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        for (int i = 0; i < n; i++) {
            for (int j = 0; j <= n; j++) {
                a[i][j] = sc.nextDouble();
            }
        }
        int res = gaussJordanElimination();
        if (res == 0) {
            for (int i = 0; i < n; i++) {
                if (Math.abs(a[i][n]) < eps) a[i][n] = 0;// 去掉输出 -0.00 的情况
                System.out.printf("%.2f\n", a[i][n]);
            }
        } else if (res == 1) {
            System.out.println("Infinite group solutions");
        } else {
            System.out.println("No solution");
        }
    }
}